(function webpackUniversalModuleDefinition(root, factory) {
  if (typeof exports === 'object' && typeof module === 'object')
    module.exports = factory();
  else if (typeof define === 'function' && define.amd)
    define([], factory);
  else {
    var a = factory();
    for (var i in a)(typeof exports === 'object' ? exports : root)[i] = a[i];
  }
})(this, function() {
  return /******/ (function(modules) { // webpackBootstrap
    /******/ // The module cache
    /******/
    var installedModules = {};
    /******/
    /******/ // The require function
    /******/
    function __webpack_require__(moduleId) {
      /******/
      /******/ // Check if module is in cache
      /******/
      if (installedModules[moduleId]) {
        /******/
        return installedModules[moduleId].exports;
        /******/
      }
      /******/ // Create a new module (and put it into the cache)
      /******/
      var module = installedModules[moduleId] = {
        /******/
        i: moduleId,
        /******/
        l: false,
        /******/
        exports: {}
        /******/
      };
      /******/
      /******/ // Execute the module function
      /******/
      modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
      /******/
      /******/ // Flag the module as loaded
      /******/
      module.l = true;
      /******/
      /******/ // Return the exports of the module
      /******/
      return module.exports;
      /******/
    }
    /******/
    /******/
    /******/ // expose the modules object (__webpack_modules__)
    /******/
    __webpack_require__.m = modules;
    /******/
    /******/ // expose the module cache
    /******/
    __webpack_require__.c = installedModules;
    /******/
    /******/ // identity function for calling harmony imports with the correct context
    /******/
    __webpack_require__.i = function(value) {
      return value;
    };
    /******/
    /******/ // define getter function for harmony exports
    /******/
    __webpack_require__.d = function(exports, name, getter) {
      /******/
      if (!__webpack_require__.o(exports, name)) {
        /******/
        Object.defineProperty(exports, name, {
          /******/
          configurable: false,
          /******/
          enumerable: true,
          /******/
          get: getter
          /******/
        });
        /******/
      }
      /******/
    };
    /******/
    /******/ // getDefaultExport function for compatibility with non-harmony modules
    /******/
    __webpack_require__.n = function(module) {
      /******/
      var getter = module && module.__esModule ?
        /******/
        function getDefault() {
          return module['default'];
        } :
        /******/
        function getModuleExports() {
          return module;
        };
      /******/
      __webpack_require__.d(getter, 'a', getter);
      /******/
      return getter;
      /******/
    };
    /******/
    /******/ // Object.prototype.hasOwnProperty.call
    /******/
    __webpack_require__.o = function(object, property) {
      return Object.prototype.hasOwnProperty.call(object, property);
    };
    /******/
    /******/ // __webpack_public_path__
    /******/
    __webpack_require__.p = "";
    /******/
    /******/ // Load entry module and return exports
    /******/
    return __webpack_require__(__webpack_require__.s = 11);
    /******/
  })
  /************************************************************************/
  /******/
  ([
    /* 0 */
    /***/
    (function(module, exports, __webpack_require__) {

      "use strict";


      var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
        return typeof obj;
      } : function(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };

      module.exports = {
        type: function type(ob) {
          return Object.prototype.toString.call(ob).slice(8, -1).toLowerCase();
        },
        isObject: function isObject(ob, real) {
          if (real) {
            return this.type(ob) === "object";
          } else {
            return ob && (typeof ob === 'undefined' ? 'undefined' : _typeof(ob)) === 'object';
          }
        },
        isFormData: function isFormData(val) {
          return typeof FormData !== 'undefined' && val instanceof FormData;
        },
        trim: function trim(str) {
          return str.replace(/(^\s*)|(\s*$)/g, '');
        },
        encode: function encode(val) {
          return encodeURIComponent(val).replace(/%40/gi, '@').replace(/%3A/gi, ':').replace(/%24/g, '$').replace(/%2C/gi, ',').replace(/%20/g, '+').replace(/%5B/gi, '[').replace(/%5D/gi, ']');
        },
        formatParams: function formatParams(data) {
          var str = "";
          var first = true;
          var that = this;

          function _encode(sub, path) {
            var encode = that.encode;
            var type = that.type(sub);
            if (type == "array") {
              sub.forEach(function(e, i) {
                _encode(e, path + "%5B%5D");
              });
            } else if (type == "object") {
              for (var key in sub) {
                if (path) {
                  _encode(sub[key], path + "%5B" + encode(key) + "%5D");
                } else {
                  _encode(sub[key], encode(key));
                }
              }
            } else {
              if (!first) {
                str += "&";
              }
              first = false;
              str += path + "=" + encode(sub);
            }
          }

          _encode(data, "");
          return str;
        },

        // Do not overwrite existing attributes
        merge: function merge(a, b) {
          for (var key in b) {
            if (!a.hasOwnProperty(key)) {
              a[key] = b[key];
            } else if (this.isObject(b[key], 1) && this.isObject(a[key], 1)) {
              this.merge(a[key], b[key]);
            }
          }
          return a;
        }
      };

      /***/
    }),
    /* 1 */
    /***/
    (function(module, exports, __webpack_require__) {

      function KEEP(_, cb) {
        cb();
      }
      "use strict";

      var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
        return typeof obj;
      } : function(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
      };

      var _createClass = function() {
        function defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }
        return function(Constructor, protoProps, staticProps) {
          if (protoProps) defineProperties(Constructor.prototype, protoProps);
          if (staticProps) defineProperties(Constructor, staticProps);
          return Constructor;
        };
      }();

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }

      /*
       * author: wendu
       * email: 824783146@qq.com
       **/

      var util = __webpack_require__(0);
      var isBrowser = typeof document !== "undefined";

      //EngineWrapper can help  generating  a  http engine quickly through a adapter
      function EngineWrapper(adapter) {
        var AjaxEngine = function() {
          function AjaxEngine() {
            _classCallCheck(this, AjaxEngine);

            this.requestHeaders = {};
            this.readyState = 0;
            this.timeout = 0; // 0 stands for no timeout
            this.responseURL = "";
            this.responseHeaders = {};
          }

          _createClass(AjaxEngine, [{
            key: "_call",
            value: function _call(name) {
              this[name] && this[name].apply(this, [].splice.call(arguments, 1));
            }
          }, {
            key: "_changeReadyState",
            value: function _changeReadyState(state) {
              this.readyState = state;
              this._call("onreadystatechange");
            }
          }, {
            key: "open",
            value: function open(method, url) {
              this.method = method;
              if (!url) {
                url = location.href;
              } else {
                url = util.trim(url);
                if (url.indexOf("http") !== 0) {
                  // Normalize the request url
                  if (isBrowser) {
                    var t = document.createElement("a");
                    t.href = url;
                    url = t.href;
                  }
                }
              }
              this.responseURL = url;
              this._changeReadyState(1);
            }
          }, {
            key: "send",
            value: function send(arg) {
              var _this = this;

              arg = arg || null;
              if (isBrowser) {
                var cookie = document.cookie;
                if (cookie) {
                  this.requestHeaders.cookie = cookie;
                }
              }
              var self = this;
              if (adapter) {
                var request = {
                  method: self.method,
                  url: self.responseURL,
                  headers: self.requestHeaders || {},
                  body: arg
                };
                util.merge(request, self._options || {});
                if (request.method === "GET") {
                  request.body = null;
                }
                self._changeReadyState(3);
                var timer;
                self.timeout = self.timeout || 0;
                if (self.timeout > 0) {
                  timer = setTimeout(function() {
                    if (self.readyState === 3) {
                      _this._call("onloadend");
                      self._changeReadyState(0);
                      self._call("ontimeout");
                    }
                  }, self.timeout);
                }
                request.timeout = self.timeout;
                adapter(request, function(response) {

                  function getAndDelete(key) {
                    var t = response[key];
                    delete response[key];
                    return t;
                  }

                  // If the request has already timeout, return
                  if (self.readyState !== 3) return;
                  clearTimeout(timer);

                  // Make sure the type of status is integer
                  self.status = getAndDelete("statusCode") - 0;

                  var responseText = getAndDelete("responseText");
                  var statusMessage = getAndDelete("statusMessage");

                  // Network error, set the status code 0
                  if (!self.status) {
                    self.statusText = responseText;
                    self._call("onerror", {
                      msg: statusMessage
                    });
                  } else {
                    // Parsing the response headers to array in a object,  because
                    // there may be multiple values with the same header name
                    var responseHeaders = getAndDelete("headers");
                    var headers = {};
                    for (var field in responseHeaders) {
                      var value = responseHeaders[field];
                      var key = field.toLowerCase();
                      // Is array
                      if ((typeof value === "undefined" ? "undefined" : _typeof(value)) === "object") {
                        headers[key] = value;
                      } else {
                        headers[key] = headers[key] || [];
                        headers[key].push(value);
                      }
                    }
                    var cookies = headers["set-cookie"];
                    if (isBrowser && cookies) {
                      cookies.forEach(function(e) {
                        // Remove the http-Only property of the  cookie
                        // so that JavaScript can operate it.
                        document.cookie = e.replace(/;\s*httpOnly/ig, "");
                      });
                    }
                    self.responseHeaders = headers;
                    // Set the fields of engine from response
                    self.statusText = statusMessage || "";
                    self.response = self.responseText = responseText;
                    self._response = response;
                    self._changeReadyState(4);
                    self._call("onload");
                  }
                  self._call("onloadend");
                });
              } else {
                console.error("Ajax require adapter");
              }
            }
          }, {
            key: "setRequestHeader",
            value: function setRequestHeader(key, value) {
              this.requestHeaders[util.trim(key)] = value;
            }
          }, {
            key: "getResponseHeader",
            value: function getResponseHeader(key) {
              return (this.responseHeaders[key.toLowerCase()] || "").toString() || null;
            }
          }, {
            key: "getAllResponseHeaders",
            value: function getAllResponseHeaders() {
              var str = "";
              for (var key in this.responseHeaders) {
                str += key + ":" + this.getResponseHeader(key) + "\r\n";
              }
              return str || null;
            }
          }, {
            key: "abort",
            value: function abort(msg) {
              this._changeReadyState(0);
              this._call("onerror", {
                msg: msg
              });
              this._call("onloadend");
            }
          }], [{
            key: "setAdapter",
            value: function setAdapter(requestAdapter) {
              adapter = requestAdapter;
            }
          }]);

          return AjaxEngine;
        }();

        return AjaxEngine;
      }

      // learn more about keep-loader: https://github.com/wendux/keep-loader
      ;
      module.exports = EngineWrapper;

      /***/
    }),
    /* 2 */
    /***/
    (function(module, exports, __webpack_require__) {

      function KEEP(_, cb) {
        cb();
      }
      "use strict";

      var _createClass = function() {
        function defineProperties(target, props) {
          for (var i = 0; i < props.length; i++) {
            var descriptor = props[i];
            descriptor.enumerable = descriptor.enumerable || false;
            descriptor.configurable = true;
            if ("value" in descriptor) descriptor.writable = true;
            Object.defineProperty(target, descriptor.key, descriptor);
          }
        }
        return function(Constructor, protoProps, staticProps) {
          if (protoProps) defineProperties(Constructor.prototype, protoProps);
          if (staticProps) defineProperties(Constructor, staticProps);
          return Constructor;
        };
      }();

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }

      var utils = __webpack_require__(0);
      var isBrowser = typeof document !== "undefined";

      var Fly = function() {
        function Fly(engine) {
          _classCallCheck(this, Fly);

          this.engine = engine || XMLHttpRequest;

          this.default = this; //For typeScript

          /**
           * Add  lock/unlock API for interceptor.
           *
           * Once an request/response interceptor is locked, the incoming request/response
           * will be added to a queue before they enter the interceptor, they will not be
           * continued  until the interceptor is unlocked.
           *
           * @param [interceptor] either is interceptors.request or interceptors.response
           */
          function wrap(interceptor) {
            var completer;
            utils.merge(interceptor, {
              lock: function lock() {
                if (!completer) {
                  interceptor.p = new Promise(function(resolve) {
                    completer = resolve;
                  });
                }
              },
              unlock: function unlock() {
                if (completer) {
                  completer();
                  interceptor.p = completer = null;
                }
              }
            });
          }

          var interceptors = this.interceptors = {
            response: {
              use: function use(handler, onerror) {
                this.handler = handler;
                this.onerror = onerror;
              }
            },
            request: {
              use: function use(handler) {
                this.handler = handler;
              }
            }
          };

          var irq = interceptors.request;
          var irp = interceptors.response;
          wrap(irp);
          wrap(irq);

          this.config = {
            method: "GET",
            baseURL: "",
            headers: {},
            timeout: 0,
            parseJson: true, // Convert response data to JSON object automatically.
            withCredentials: false
          };
        }

        _createClass(Fly, [{
          key: "request",
          value: function request(url, data, options) {
            var _this = this;

            var engine = new this.engine();
            var contentType = "Content-Type";
            var contentTypeLowerCase = contentType.toLowerCase();
            var interceptors = this.interceptors;
            var requestInterceptor = interceptors.request;
            var responseInterceptor = interceptors.response;
            var requestInterceptorHandler = requestInterceptor.handler;
            var promise = new Promise(function(resolve, reject) {
              if (utils.isObject(url)) {
                options = url;
                url = options.url;
              }
              options = options || {};
              options.headers = options.headers || {};

              function isPromise(p) {
                // some  polyfill implementation of Promise may be not standard,
                // so, we test by duck-typing
                return p && p.then && p.catch;
              }

              /**
               * If the request/response interceptor has been locked，
               * the new request/response will enter a queue. otherwise, it will be performed directly.
               * @param [promise] if the promise exist, means the interceptor is  locked.
               * @param [callback]
               */
              function enqueueIfLocked(promise, callback) {
                if (promise) {
                  promise.then(function() {
                    callback();
                  });
                } else {
                  callback();
                }
              }

              // make the http request
              function makeRequest(options) {
                data = options.body;
                // Normalize the request url
                url = utils.trim(options.url);
                var baseUrl = utils.trim(options.baseURL || "");
                if (!url && isBrowser && !baseUrl) url = location.href;
                if (url.indexOf("http") !== 0) {
                  var isAbsolute = url[0] === "/";
                  if (!baseUrl && isBrowser) {
                    var arr = location.pathname.split("/");
                    arr.pop();
                    baseUrl = location.protocol + "//" + location.host + (isAbsolute ? "" : arr.join("/"));
                  }
                  if (baseUrl[baseUrl.length - 1] !== "/") {
                    baseUrl += "/";
                  }
                  url = baseUrl + (isAbsolute ? url.substr(1) : url);
                  if (isBrowser) {

                    // Normalize the url which contains the ".." or ".", such as
                    // "http://xx.com/aa/bb/../../xx" to "http://xx.com/xx" .
                    var t = document.createElement("a");
                    t.href = url;
                    url = t.href;
                  }
                }

                var responseType = utils.trim(options.responseType || "");
                engine.withCredentials = !!options.withCredentials;
                var isGet = options.method === "GET";
                if (isGet) {
                  if (data) {
                    if (utils.type(data) !== "string") {
                      data = utils.formatParams(data);
                    }
                    url += (url.indexOf("?") === -1 ? "?" : "&") + data;
                  }
                }
                engine.open(options.method, url);

                // try catch for ie >=9
                try {
                  engine.timeout = options.timeout || 0;
                  if (responseType !== "stream") {
                    engine.responseType = responseType;
                  }
                } catch (e) {}

                if (!isGet) {
                  // If the request data is json object, transforming it  to json string,
                  // and set request content-type to "json". In browser,  the data will
                  // be sent as RequestBody instead of FormData
                  if (options.headers[contentType].toLowerCase() === "application/x-www-form-urlencoded") {
                    data = utils.formatParams(data);
                  } else if (!utils.isFormData(data) && ["object", "array"].indexOf(utils.type(data)) !== -1) {
                    options.headers[contentType] = 'application/json;charset=utf-8';
                    data = JSON.stringify(data);
                  }
                }

                for (var k in options.headers) {
                  if (k === contentType && (utils.isFormData(data) || !data || isGet)) {
                    // Delete the content-type, Let the browser set it
                    delete options.headers[k];
                  } else {
                    try {
                      // In browser environment, some header fields are readonly,
                      // write will cause the exception .
                      engine.setRequestHeader(k, options.headers[k]);
                    } catch (e) {}
                  }
                }

                function onresult(handler, data, type) {
                  enqueueIfLocked(responseInterceptor.p, function() {
                    if (handler) {
                      //如果失败，添加请求信息
                      if (type) {
                        data.request = options;
                      }
                      var ret = handler.call(responseInterceptor, data, Promise);
                      data = ret === undefined ? data : ret;
                    }
                    if (!isPromise(data)) {
                      data = Promise[type === 0 ? "resolve" : "reject"](data);
                    }
                    data.then(function(d) {
                      resolve(d);
                    }).catch(function(e) {
                      reject(e);
                    });
                  });
                }

                function onerror(e) {
                  e.engine = engine;
                  onresult(responseInterceptor.onerror, e, -1);
                }

                function Err(msg, status) {
                  this.message = msg;
                  this.status = status;
                }

                engine.onload = function() {
                  // The xhr of IE9 has not response filed
                  var response = engine.response || engine.responseText;
                  if (options.parseJson && (engine.getResponseHeader(contentType) || "").indexOf("json") !== -1
                    // Some third engine implementation may transform the response text to json object automatically,
                    // so we should test the type of response before transforming it
                    &&
                    !utils.isObject(response)) {
                    response = JSON.parse(response);
                  }
                  var headers = {};
                  var items = (engine.getAllResponseHeaders() || "").split("\r\n");
                  items.pop();
                  items.forEach(function(e) {
                    var key = e.split(":")[0];
                    headers[key] = engine.getResponseHeader(key);
                  });
                  var status = engine.status;
                  var statusText = engine.statusText;
                  var data = {
                    data: response,
                    headers: headers,
                    status: status,
                    statusText: statusText
                  };
                  // The _response filed of engine is set in  adapter which be called in engine-wrapper.js
                  utils.merge(data, engine._response);
                  if (status >= 200 && status < 300 || status === 304) {
                    data.engine = engine;
                    data.request = options;
                    onresult(responseInterceptor.handler, data, 0);
                  } else {
                    var e = new Err(statusText, status);
                    e.response = data;
                    onerror(e);
                  }
                };

                engine.onerror = function(e) {
                  onerror(new Err(e.msg || "Network Error", 0));
                };

                engine.ontimeout = function() {
                  onerror(new Err("timeout [ " + engine.timeout + "ms ]", 1));
                };
                engine._options = options;
                setTimeout(function() {
                  engine.send(isGet ? null : data);
                }, 0);
              }

              enqueueIfLocked(requestInterceptor.p, function() {
                utils.merge(options, _this.config);
                var headers = options.headers;
                headers[contentType] = headers[contentType] || headers[contentTypeLowerCase] || "";
                delete headers[contentTypeLowerCase];
                options.body = data || options.body;
                url = utils.trim(url || "");
                options.method = options.method.toUpperCase();
                options.url = url;
                var ret = options;
                if (requestInterceptorHandler) {
                  ret = requestInterceptorHandler.call(requestInterceptor, options, Promise) || options;
                }
                if (!isPromise(ret)) {
                  ret = Promise.resolve(ret);
                }
                ret.then(function(d) {
                  //if options continue
                  if (d === options) {
                    makeRequest(d);
                  } else {
                    resolve(d);
                  }
                }, function(err) {
                  reject(err);
                });
              });
            });
            promise.engine = engine;
            return promise;
          }
        }, {
          key: "all",
          value: function all(promises) {
            return Promise.all(promises);
          }
        }, {
          key: "spread",
          value: function spread(callback) {
            return function(arr) {
              return callback.apply(null, arr);
            };
          }
        }, {
          key: "lock",
          value: function lock() {
            this.interceptors.request.lock();
          }
        }, {
          key: "unlock",
          value: function unlock() {
            this.interceptors.request.unlock();
          }
        }]);

        return Fly;
      }();

      //For typeScript


      Fly.default = Fly;

      ["get", "post", "put", "patch", "head", "delete"].forEach(function(e) {
        Fly.prototype[e] = function(url, data, option) {
          return this.request(url, data, utils.merge({
            method: e
          }, option));
        };
      });
      // Learn more about keep-loader: https://github.com/wendux/keep-loader
      ;
      module.exports = Fly;

      /***/
    }),
    /* 3 */
    ,
    /* 4 */
    ,
    /* 5 */
    ,
    /* 6 */
    /***/
    (function(module, exports, __webpack_require__) {

      "use strict";


      //微信小程序适配器
      module.exports = function(request, responseCallback) {
        var con = {
          method: request.method,
          url: request.url,
          dataType: request.dataType || undefined,
          header: request.headers,
          data: request.body || {},
          success: function success(res) {
            responseCallback({
              statusCode: res.statusCode,
              responseText: res.data,
              headers: res.header,
              statusMessage: res.errMsg
            });
          },
          fail: function fail(res) {
            responseCallback({
              statusCode: res.statusCode || 0,
              statusMessage: res.errMsg
            });
          }
        };
        wx.request(con);
      };

      /***/
    }),
    /* 7 */
    ,
    /* 8 */
    ,
    /* 9 */
    ,
    /* 10 */
    ,
    /* 11 */
    /***/
    (function(module, exports, __webpack_require__) {

      "use strict";


      //微信小程序入口
      var Fly = __webpack_require__(2);
      var EngineWrapper = __webpack_require__(1);
      var adapter = __webpack_require__(6);
      var wxEngine = EngineWrapper(adapter);
      module.exports = function(engine) {
        return new Fly(engine || wxEngine);
      };

      /***/
    })
    /******/
  ]);
});